_gtk_socket_windowing_end_embedding_toplevel (GtkSocket *socket)
{
gtk_window_remove_embedded_xid (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (socket))),
- GDK_WINDOW_XID (socket->plug_window));
+ GDK_WINDOW_XID (socket->priv->plug_window));
}
void
_gtk_socket_windowing_size_request (GtkSocket *socket)
{
+ GtkSocketPrivate *private = socket->priv;
XSizeHints hints;
long supplied;
gdk_error_trap_push ();
- socket->request_width = 1;
- socket->request_height = 1;
+ private->request_width = 1;
+ private->request_height = 1;
- if (XGetWMNormalHints (GDK_WINDOW_XDISPLAY (socket->plug_window),
- GDK_WINDOW_XID (socket->plug_window),
+ if (XGetWMNormalHints (GDK_WINDOW_XDISPLAY (private->plug_window),
+ GDK_WINDOW_XID (private->plug_window),
&hints, &supplied))
{
if (hints.flags & PMinSize)
{
- socket->request_width = MAX (hints.min_width, 1);
- socket->request_height = MAX (hints.min_height, 1);
+ private->request_width = MAX (hints.min_width, 1);
+ private->request_height = MAX (hints.min_height, 1);
}
else if (hints.flags & PBaseSize)
{
- socket->request_width = MAX (hints.base_width, 1);
- socket->request_height = MAX (hints.base_height, 1);
+ private->request_width = MAX (hints.base_width, 1);
+ private->request_height = MAX (hints.base_height, 1);
}
}
- socket->have_size = TRUE;
+ private->have_size = TRUE;
gdk_error_trap_pop_ignored ();
}
gboolean mask_key_presses)
{
XKeyEvent xkey;
- GdkScreen *screen = gdk_window_get_screen (socket->plug_window);
+ GdkScreen *screen = gdk_window_get_screen (socket->priv->plug_window);
memset (&xkey, 0, sizeof (xkey));
xkey.type = (gdk_event->type == GDK_KEY_PRESS) ? KeyPress : KeyRelease;
- xkey.window = GDK_WINDOW_XID (socket->plug_window);
+ xkey.window = GDK_WINDOW_XID (socket->priv->plug_window);
xkey.root = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
xkey.subwindow = None;
xkey.time = gdk_event->key.time;
xkey.same_screen = True;/* FIXME ? */
gdk_error_trap_push ();
- XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
- GDK_WINDOW_XID (socket->plug_window),
+ XSendEvent (GDK_WINDOW_XDISPLAY (socket->priv->plug_window),
+ GDK_WINDOW_XID (socket->priv->plug_window),
False,
(mask_key_presses ? KeyPressMask : NoEventMask),
(XEvent *)&xkey);
gboolean focus_in)
{
if (focus_in)
- _gtk_xembed_send_focus_message (socket->plug_window,
+ _gtk_xembed_send_focus_message (socket->priv->plug_window,
XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT);
else
- _gtk_xembed_send_message (socket->plug_window,
+ _gtk_xembed_send_message (socket->priv->plug_window,
XEMBED_FOCUS_OUT, 0, 0, 0);
}
_gtk_socket_windowing_update_active (GtkSocket *socket,
gboolean active)
{
- _gtk_xembed_send_message (socket->plug_window,
+ _gtk_xembed_send_message (socket->priv->plug_window,
active ? XEMBED_WINDOW_ACTIVATE : XEMBED_WINDOW_DEACTIVATE,
0, 0, 0);
}
_gtk_socket_windowing_update_modality (GtkSocket *socket,
gboolean modality)
{
- _gtk_xembed_send_message (socket->plug_window,
+ _gtk_xembed_send_message (socket->priv->plug_window,
modality ? XEMBED_MODALITY_ON : XEMBED_MODALITY_OFF,
0, 0, 0);
}
break;
}
- _gtk_xembed_send_focus_message (socket->plug_window, XEMBED_FOCUS_IN, detail);
+ _gtk_xembed_send_focus_message (socket->priv->plug_window, XEMBED_FOCUS_IN, detail);
}
void
XConfigureEvent xconfigure;
gint x, y;
- g_return_if_fail (socket->plug_window != NULL);
+ g_return_if_fail (socket->priv->plug_window != NULL);
memset (&xconfigure, 0, sizeof (xconfigure));
xconfigure.type = ConfigureNotify;
- xconfigure.event = GDK_WINDOW_XID (socket->plug_window);
- xconfigure.window = GDK_WINDOW_XID (socket->plug_window);
+ xconfigure.event = GDK_WINDOW_XID (socket->priv->plug_window);
+ xconfigure.window = GDK_WINDOW_XID (socket->priv->plug_window);
/* The ICCCM says that synthetic events should have root relative
* coordinates. We still aren't really ICCCM compliant, since
* we don't send events when the real toplevel is moved.
*/
gdk_error_trap_push ();
- gdk_window_get_origin (socket->plug_window, &x, &y);
+ gdk_window_get_origin (socket->priv->plug_window, &x, &y);
gdk_error_trap_pop_ignored ();
gtk_widget_get_allocation (GTK_WIDGET(socket), &allocation);
xconfigure.override_redirect = False;
gdk_error_trap_push ();
- XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
- GDK_WINDOW_XID (socket->plug_window),
+ XSendEvent (GDK_WINDOW_XDISPLAY (socket->priv->plug_window),
+ GDK_WINDOW_XID (socket->priv->plug_window),
False, NoEventMask, (XEvent *)&xconfigure);
gdk_error_trap_pop_ignored ();
}
_gtk_socket_windowing_select_plug_window_input (GtkSocket *socket)
{
XSelectInput (GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (socket))),
- GDK_WINDOW_XID (socket->plug_window),
+ GDK_WINDOW_XID (socket->priv->plug_window),
StructureNotifyMask | PropertyChangeMask);
}
{
unsigned long version;
unsigned long flags;
+ GtkSocketPrivate *private = socket->priv;
- socket->xembed_version = -1;
- if (xembed_get_info (socket->plug_window, &version, &flags))
+ private->xembed_version = -1;
+ if (xembed_get_info (private->plug_window, &version, &flags))
{
- socket->xembed_version = MIN (GTK_XEMBED_PROTOCOL_VERSION, version);
- socket->is_mapped = (flags & XEMBED_MAPPED) != 0;
+ private->xembed_version = MIN (GTK_XEMBED_PROTOCOL_VERSION, version);
+ private->is_mapped = (flags & XEMBED_MAPPED) != 0;
}
else
{
/* FIXME, we should probably actually check the state before we started */
- socket->is_mapped = TRUE;
+ private->is_mapped = TRUE;
}
}
void
_gtk_socket_windowing_embed_notify (GtkSocket *socket)
{
+ GtkSocketPrivate *private = socket->priv;
#ifdef HAVE_XFIXES
GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (socket));
gdk_error_trap_push ();
XFixesChangeSaveSet (GDK_DISPLAY_XDISPLAY (display),
- GDK_WINDOW_XID (socket->plug_window),
+ GDK_WINDOW_XID (private->plug_window),
SetModeInsert, SaveSetRoot, SaveSetUnmap);
gdk_error_trap_pop_ignored ();
#endif
- _gtk_xembed_send_message (socket->plug_window,
+ _gtk_xembed_send_message (private->plug_window,
XEMBED_EMBEDDED_NOTIFY, 0,
GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (socket))),
- socket->xembed_version);
+ private->xembed_version);
}
static gboolean
GtkWidget *widget;
GdkDisplay *display;
XEvent *xevent;
+ GtkSocketPrivate *private;
GdkFilterReturn return_val;
-
+
socket = GTK_SOCKET (data);
+ private = socket->priv;
return_val = GDK_FILTER_CONTINUE;
- if (socket->plug_widget)
+ if (private->plug_widget)
return return_val;
widget = GTK_WIDGET (socket);
{
XCreateWindowEvent *xcwe = &xevent->xcreatewindow;
- if (!socket->plug_window)
+ if (!private->plug_window)
{
_gtk_socket_add_window (socket, xcwe->window, FALSE);
- if (socket->plug_window)
+ if (private->plug_window)
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - window created"));
}
{
XConfigureRequestEvent *xcre = &xevent->xconfigurerequest;
- if (!socket->plug_window)
+ if (!private->plug_window)
_gtk_socket_add_window (socket, xcre->window, FALSE);
- if (socket->plug_window)
+ if (private->plug_window)
{
- GtkSocketPrivate *private = _gtk_socket_get_private (socket);
-
if (xcre->value_mask & (CWWidth | CWHeight))
{
GTK_NOTE (PLUGSOCKET,
g_message ("GtkSocket - configure request: %d %d",
- socket->request_width,
- socket->request_height));
+ private->request_width,
+ private->request_height));
private->resize_count++;
gtk_widget_queue_resize (widget);
/* Note that we get destroy notifies both from SubstructureNotify on
* our window and StructureNotify on socket->plug_window
*/
- if (socket->plug_window && (xdwe->window == GDK_WINDOW_XID (socket->plug_window)))
+ if (private->plug_window && (xdwe->window == GDK_WINDOW_XID (private->plug_window)))
{
gboolean result;
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - destroy notify"));
- gdk_window_destroy_notify (socket->plug_window);
+ gdk_window_destroy_notify (private->plug_window);
_gtk_socket_end_embedding (socket);
g_object_ref (widget);
return_val = GDK_FILTER_REMOVE;
break;
case MapRequest:
- if (!socket->plug_window)
+ if (!private->plug_window)
{
_gtk_socket_add_window (socket, xevent->xmaprequest.window, FALSE);
}
- if (socket->plug_window)
+ if (private->plug_window)
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - Map Request"));
}
break;
case PropertyNotify:
- if (socket->plug_window &&
- xevent->xproperty.window == GDK_WINDOW_XID (socket->plug_window))
+ if (private->plug_window &&
+ xevent->xproperty.window == GDK_WINDOW_XID (private->plug_window))
{
GdkDragProtocol protocol;
if (xevent->xproperty.atom == gdk_x11_get_xatom_by_name_for_display (display, "WM_NORMAL_HINTS"))
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - received PropertyNotify for plug's WM_NORMAL_HINTS"));
- socket->have_size = FALSE;
+ private->have_size = FALSE;
gtk_widget_queue_resize (widget);
return_val = GDK_FILTER_REMOVE;
}
xevent->xproperty.window,
&protocol))
gtk_drag_dest_set_proxy (GTK_WIDGET (socket),
- socket->plug_window,
+ private->plug_window,
protocol, TRUE);
gdk_error_trap_pop_ignored ();
{
unsigned long flags;
- if (xembed_get_info (socket->plug_window, NULL, &flags))
+ if (xembed_get_info (private->plug_window, NULL, &flags))
{
- gboolean was_mapped = socket->is_mapped;
+ gboolean was_mapped = private->is_mapped;
gboolean is_mapped = (flags & XEMBED_MAPPED) != 0;
if (was_mapped != is_mapped)
else
{
gdk_error_trap_push ();
- gdk_window_show (socket->plug_window);
+ gdk_window_show (private->plug_window);
gdk_error_trap_pop_ignored ();
_gtk_socket_unmap_notify (socket);
window = gtk_widget_get_window (widget);
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - ReparentNotify received"));
- if (!socket->plug_window &&
+ if (!private->plug_window &&
xre->parent == GDK_WINDOW_XID (window))
{
_gtk_socket_add_window (socket, xre->window, FALSE);
- if (socket->plug_window)
+ if (private->plug_window)
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - window reparented"));
}
}
else
{
- if (socket->plug_window &&
- xre->window == GDK_WINDOW_XID (socket->plug_window) &&
+ if (private->plug_window &&
+ xre->window == GDK_WINDOW_XID (private->plug_window) &&
xre->parent != GDK_WINDOW_XID (window))
{
gboolean result;
break;
}
case UnmapNotify:
- if (socket->plug_window &&
- xevent->xunmap.window == GDK_WINDOW_XID (socket->plug_window))
+ if (private->plug_window &&
+ xevent->xunmap.window == GDK_WINDOW_XID (private->plug_window))
{
GTK_NOTE (PLUGSOCKET, g_message ("GtkSocket - Unmap notify"));
static guint socket_signals[LAST_SIGNAL] = { 0 };
-/*
- * _gtk_socket_get_private:
- *
- * @socket: a #GtkSocket
- *
- * Returns the private data associated with a GtkSocket, creating it
- * first if necessary.
- */
-GtkSocketPrivate *
-_gtk_socket_get_private (GtkSocket *socket)
-{
- return G_TYPE_INSTANCE_GET_PRIVATE (socket, GTK_TYPE_SOCKET, GtkSocketPrivate);
-}
-
G_DEFINE_TYPE (GtkSocket, gtk_socket, GTK_TYPE_CONTAINER)
static void
gtk_socket_finalize (GObject *object)
{
GtkSocket *socket = GTK_SOCKET (object);
-
- g_object_unref (socket->accel_group);
- socket->accel_group = NULL;
+ GtkSocketPrivate *priv = socket->priv;
+
+ g_object_unref (priv->accel_group);
G_OBJECT_CLASS (gtk_socket_parent_class)->finalize (object);
}
/* We don't want to show_all the in-process plug, if any.
*/
widget_class->show_all = gtk_widget_show;
-
+
container_class->remove = gtk_socket_remove;
container_class->forall = gtk_socket_forall;
static void
gtk_socket_init (GtkSocket *socket)
{
- socket->request_width = 0;
- socket->request_height = 0;
- socket->current_width = 0;
- socket->current_height = 0;
-
- socket->plug_window = NULL;
- socket->plug_widget = NULL;
- socket->focus_in = FALSE;
- socket->have_size = FALSE;
- socket->need_map = FALSE;
- socket->active = FALSE;
-
- socket->accel_group = gtk_accel_group_new ();
- g_object_set_data (G_OBJECT (socket->accel_group), I_("gtk-socket"), socket);
+ GtkSocketPrivate *priv;
+
+ priv = G_TYPE_INSTANCE_GET_PRIVATE (socket,
+ GTK_TYPE_SOCKET,
+ GtkSocketPrivate);
+ socket->priv = priv;
+ priv->request_width = 0;
+ priv->request_height = 0;
+ priv->current_width = 0;
+ priv->current_height = 0;
+
+ priv->plug_window = NULL;
+ priv->plug_widget = NULL;
+ priv->focus_in = FALSE;
+ priv->have_size = FALSE;
+ priv->need_map = FALSE;
+ priv->active = FALSE;
+
+ priv->accel_group = gtk_accel_group_new ();
+ g_object_set_data (G_OBJECT (priv->accel_group), I_("gtk-socket"), socket);
}
/**
{
g_return_val_if_fail (GTK_IS_SOCKET (socket), NULL);
- return socket->plug_window;
+ return socket->priv->plug_window;
}
static void
void
_gtk_socket_end_embedding (GtkSocket *socket)
{
- GtkSocketPrivate *private = _gtk_socket_get_private (socket);
+ GtkSocketPrivate *private = socket->priv;
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
-
+
if (GTK_IS_WINDOW (toplevel))
_gtk_socket_windowing_end_embedding_toplevel (socket);
- g_object_unref (socket->plug_window);
- socket->plug_window = NULL;
- socket->current_width = 0;
- socket->current_height = 0;
+ g_object_unref (private->plug_window);
+ private->plug_window = NULL;
+ private->current_width = 0;
+ private->current_height = 0;
private->resize_count = 0;
- gtk_accel_group_disconnect (socket->accel_group, NULL);
+ gtk_accel_group_disconnect (private->accel_group, NULL);
}
static void
gtk_socket_unrealize (GtkWidget *widget)
{
GtkSocket *socket = GTK_SOCKET (widget);
+ GtkSocketPrivate *private = socket->priv;
gtk_widget_set_realized (widget, FALSE);
- if (socket->plug_widget)
+ if (private->plug_widget)
{
- _gtk_plug_remove_from_socket (GTK_PLUG (socket->plug_widget), socket);
+ _gtk_plug_remove_from_socket (GTK_PLUG (private->plug_widget), socket);
}
- else if (socket->plug_window)
+ else if (private->plug_window)
{
_gtk_socket_end_embedding (socket);
}
gint *natural)
{
GtkSocket *socket = GTK_SOCKET (widget);
+ GtkSocketPrivate *private = socket->priv;
- if (socket->plug_widget)
+ if (private->plug_widget)
{
- gtk_widget_get_preferred_width (socket->plug_widget, minimum, natural);
+ gtk_widget_get_preferred_width (private->plug_widget, minimum, natural);
}
else
{
- if (socket->is_mapped && !socket->have_size && socket->plug_window)
+ if (private->is_mapped && !private->have_size && private->plug_window)
_gtk_socket_windowing_size_request (socket);
- if (socket->is_mapped && socket->have_size)
- *minimum = *natural = MAX (socket->request_width, 1);
+ if (private->is_mapped && private->have_size)
+ *minimum = *natural = MAX (private->request_width, 1);
else
*minimum = *natural = 1;
}
gint *natural)
{
GtkSocket *socket = GTK_SOCKET (widget);
+ GtkSocketPrivate *private = socket->priv;
- if (socket->plug_widget)
+ if (private->plug_widget)
{
- gtk_widget_get_preferred_height (socket->plug_widget, minimum, natural);
+ gtk_widget_get_preferred_height (private->plug_widget, minimum, natural);
}
else
{
- if (socket->is_mapped && !socket->have_size && socket->plug_window)
+ if (private->is_mapped && !private->have_size && private->plug_window)
_gtk_socket_windowing_size_request (socket);
- if (socket->is_mapped && socket->have_size)
- *minimum = *natural = MAX (socket->request_height, 1);
+ if (private->is_mapped && private->have_size)
+ *minimum = *natural = MAX (private->request_height, 1);
else
*minimum = *natural = 1;
}
GtkAllocation *allocation)
{
GtkSocket *socket = GTK_SOCKET (widget);
+ GtkSocketPrivate *private = socket->priv;
gtk_widget_set_allocation (widget, allocation);
if (gtk_widget_get_realized (widget))
allocation->x, allocation->y,
allocation->width, allocation->height);
- if (socket->plug_widget)
+ if (private->plug_widget)
{
GtkAllocation child_allocation;
child_allocation.width = allocation->width;
child_allocation.height = allocation->height;
- gtk_widget_size_allocate (socket->plug_widget, &child_allocation);
+ gtk_widget_size_allocate (private->plug_widget, &child_allocation);
}
- else if (socket->plug_window)
+ else if (private->plug_window)
{
- GtkSocketPrivate *private = _gtk_socket_get_private (socket);
-
gdk_error_trap_push ();
-
- if (allocation->width != socket->current_width ||
- allocation->height != socket->current_height)
+
+ if (allocation->width != private->current_width ||
+ allocation->height != private->current_height)
{
- gdk_window_move_resize (socket->plug_window,
+ gdk_window_move_resize (private->plug_window,
0, 0,
allocation->width, allocation->height);
if (private->resize_count)
GTK_NOTE (PLUGSOCKET,
g_message ("GtkSocket - allocated: %d %d",
allocation->width, allocation->height));
- socket->current_width = allocation->width;
- socket->current_height = allocation->height;
+ private->current_width = allocation->width;
+ private->current_height = allocation->height;
}
- if (socket->need_map)
+ if (private->need_map)
{
- gdk_window_show (socket->plug_window);
- socket->need_map = FALSE;
+ gdk_window_show (private->plug_window);
+ private->need_map = FALSE;
}
while (private->resize_count)
GtkSocket *socket = g_object_get_data (G_OBJECT (accel_group), "gtk-socket");
gboolean retval = FALSE;
- if (gdk_event && gdk_event->type == GDK_KEY_PRESS && socket->plug_window)
+ if (gdk_event && gdk_event->type == GDK_KEY_PRESS && socket->priv->plug_window)
{
_gtk_socket_windowing_send_key_event (socket, gdk_event, FALSE);
retval = TRUE;
grabbed_key->accel_key = keyval;
grabbed_key->accel_mods = modifiers;
- if (gtk_accel_group_find (socket->accel_group,
+ if (gtk_accel_group_find (socket->priv->accel_group,
find_accel_key,
&grabbed_key))
{
closure = g_cclosure_new (G_CALLBACK (activate_key), grabbed_key, (GClosureNotify)g_free);
- gtk_accel_group_connect (socket->accel_group, keyval, modifiers, GTK_ACCEL_LOCKED,
+ gtk_accel_group_connect (socket->priv->accel_group, keyval, modifiers, GTK_ACCEL_LOCKED,
closure);
}
guint keyval,
GdkModifierType modifiers)
{
- if (!gtk_accel_group_disconnect_key (socket->accel_group, keyval, modifiers))
+ if (!gtk_accel_group_disconnect_key (socket->priv->accel_group, keyval, modifiers))
g_warning ("GtkSocket: request to remove non-present grabbed key %u,%#x\n",
keyval, modifiers);
}
static void
socket_update_focus_in (GtkSocket *socket)
{
+ GtkSocketPrivate *private = socket->priv;
gboolean focus_in = FALSE;
- if (socket->plug_window)
+ if (private->plug_window)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
focus_in = TRUE;
}
- if (focus_in != socket->focus_in)
+ if (focus_in != private->focus_in)
{
- socket->focus_in = focus_in;
+ private->focus_in = focus_in;
_gtk_socket_windowing_focus_change (socket, focus_in);
}
static void
socket_update_active (GtkSocket *socket)
{
+ GtkSocketPrivate *private = socket->priv;
gboolean active = FALSE;
- if (socket->plug_window)
+ if (private->plug_window)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
active = TRUE;
}
- if (active != socket->active)
+ if (active != private->active)
{
- socket->active = active;
+ private->active = active;
_gtk_socket_windowing_update_active (socket, active);
}
GtkWidget *old_toplevel)
{
GtkSocket *socket = GTK_SOCKET (widget);
+ GtkSocketPrivate *private = socket->priv;
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (toplevel && !GTK_IS_WINDOW (toplevel))
toplevel = NULL;
- if (toplevel != socket->toplevel)
+ if (toplevel != private->toplevel)
{
- if (socket->toplevel)
+ if (private->toplevel)
{
- gtk_window_remove_accel_group (GTK_WINDOW (socket->toplevel), socket->accel_group);
- g_signal_handlers_disconnect_by_func (socket->toplevel,
+ gtk_window_remove_accel_group (GTK_WINDOW (private->toplevel), private->accel_group);
+ g_signal_handlers_disconnect_by_func (private->toplevel,
socket_update_focus_in,
socket);
- g_signal_handlers_disconnect_by_func (socket->toplevel,
+ g_signal_handlers_disconnect_by_func (private->toplevel,
socket_update_active,
socket);
}
- socket->toplevel = toplevel;
+ private->toplevel = toplevel;
if (toplevel)
{
- gtk_window_add_accel_group (GTK_WINDOW (socket->toplevel), socket->accel_group);
- g_signal_connect_swapped (socket->toplevel, "notify::has-toplevel-focus",
+ gtk_window_add_accel_group (GTK_WINDOW (private->toplevel), private->accel_group);
+ g_signal_connect_swapped (private->toplevel, "notify::has-toplevel-focus",
G_CALLBACK (socket_update_focus_in), socket);
- g_signal_connect_swapped (socket->toplevel, "notify::is-active",
+ g_signal_connect_swapped (private->toplevel, "notify::is-active",
G_CALLBACK (socket_update_active), socket);
}
{
GtkSocket *socket = GTK_SOCKET (widget);
- if (!socket->same_app)
+ if (!socket->priv->same_app)
_gtk_socket_windowing_update_modality (socket, !was_grabbed);
}
GdkEventKey *event)
{
GtkSocket *socket = GTK_SOCKET (widget);
+ GtkSocketPrivate *private = socket->priv;
- if (gtk_widget_has_focus (widget) && socket->plug_window && !socket->plug_widget)
+ if (gtk_widget_has_focus (widget) && private->plug_window && !private->plug_widget)
{
_gtk_socket_windowing_send_key_event (socket, (GdkEvent *) event, FALSE);
gboolean send_event)
{
GtkWidget *widget = GTK_WIDGET (socket);
+ GtkSocketPrivate *private = socket->priv;
if (!send_event)
- socket->focus_in = TRUE; /* Otherwise, our notify handler will send FOCUS_IN */
+ private->focus_in = TRUE; /* Otherwise, our notify handler will send FOCUS_IN */
/* Oh, the trickery... */
GtkDirectionType direction)
{
GtkSocket *socket = GTK_SOCKET (widget);
+ GtkSocketPrivate *private = socket->priv;
- if (socket->plug_widget)
- return gtk_widget_child_focus (socket->plug_widget, direction);
+ if (private->plug_widget)
+ return gtk_widget_child_focus (private->plug_widget, direction);
if (!gtk_widget_is_focus (widget))
{
GtkWidget *child)
{
GtkSocket *socket = GTK_SOCKET (container);
+ GtkSocketPrivate *private = socket->priv;
- g_return_if_fail (child == socket->plug_widget);
+ g_return_if_fail (child == private->plug_widget);
- _gtk_plug_remove_from_socket (GTK_PLUG (socket->plug_widget), socket);
+ _gtk_plug_remove_from_socket (GTK_PLUG (private->plug_widget), socket);
}
static void
gpointer callback_data)
{
GtkSocket *socket = GTK_SOCKET (container);
+ GtkSocketPrivate *private = socket->priv;
- if (socket->plug_widget)
- (* callback) (socket->plug_widget, callback_data);
+ if (private->plug_widget)
+ (* callback) (private->plug_widget, callback_data);
}
/**
GtkWidget *widget = GTK_WIDGET (socket);
GdkDisplay *display = gtk_widget_get_display (widget);
gpointer user_data = NULL;
+ GtkSocketPrivate *private = socket->priv;
- socket->plug_window = gdk_window_lookup_for_display (display, xid);
+ private->plug_window = gdk_window_lookup_for_display (display, xid);
- if (socket->plug_window)
+ if (private->plug_window)
{
- g_object_ref (socket->plug_window);
- gdk_window_get_user_data (socket->plug_window, &user_data);
+ g_object_ref (private->plug_window);
+ gdk_window_get_user_data (private->plug_window, &user_data);
}
if (user_data) /* A widget's window in this process */
if (!GTK_IS_PLUG (child_widget))
{
g_warning (G_STRLOC ": Can't add non-GtkPlug to GtkSocket");
- socket->plug_window = NULL;
+ private->plug_window = NULL;
gdk_error_trap_pop_ignored ();
return;
gdk_error_trap_push ();
- if (!socket->plug_window)
+ if (!private->plug_window)
{
- socket->plug_window = gdk_window_foreign_new_for_display (display, xid);
- if (!socket->plug_window) /* was deleted before we could get it */
+ private->plug_window = gdk_window_foreign_new_for_display (display, xid);
+ if (!private->plug_window) /* was deleted before we could get it */
{
gdk_error_trap_pop_ignored ();
return;
if (gdk_error_trap_pop ())
{
- g_object_unref (socket->plug_window);
- socket->plug_window = NULL;
+ g_object_unref (private->plug_window);
+ private->plug_window = NULL;
return;
}
if (need_reparent)
{
- gdk_window_hide (socket->plug_window); /* Shouldn't actually be necessary for XEMBED, but just in case */
- gdk_window_reparent (socket->plug_window,
+ gdk_window_hide (private->plug_window); /* Shouldn't actually be necessary for XEMBED, but just in case */
+ gdk_window_reparent (private->plug_window,
gtk_widget_get_window (widget),
0, 0);
}
- socket->have_size = FALSE;
+ private->have_size = FALSE;
_gtk_socket_windowing_embed_get_info (socket);
- socket->need_map = socket->is_mapped;
+ private->need_map = private->is_mapped;
if (gdk_drag_get_protocol_for_display (display, xid, &protocol))
- gtk_drag_dest_set_proxy (GTK_WIDGET (socket), socket->plug_window,
+ gtk_drag_dest_set_proxy (GTK_WIDGET (socket), private->plug_window,
protocol, TRUE);
gdk_error_trap_pop_ignored ();
- gdk_window_add_filter (socket->plug_window,
+ gdk_window_add_filter (private->plug_window,
_gtk_socket_windowing_filter_func,
socket);
gtk_widget_queue_resize (GTK_WIDGET (socket));
}
- if (socket->plug_window)
+ if (private->plug_window)
g_signal_emit (socket, socket_signals[PLUG_ADDED], 0);
}
void
_gtk_socket_handle_map_request (GtkSocket *socket)
{
- if (!socket->is_mapped)
+ GtkSocketPrivate *private = socket->priv;
+ if (!private->is_mapped)
{
- socket->is_mapped = TRUE;
- socket->need_map = TRUE;
+ private->is_mapped = TRUE;
+ private->need_map = TRUE;
gtk_widget_queue_resize (GTK_WIDGET (socket));
}
void
_gtk_socket_unmap_notify (GtkSocket *socket)
{
- if (socket->is_mapped)
+ GtkSocketPrivate *private = socket->priv;
+ if (private->is_mapped)
{
- socket->is_mapped = FALSE;
+ private->is_mapped = FALSE;
gtk_widget_queue_resize (GTK_WIDGET (socket));
}
}
projects / gtk4.git / commitdiff